home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 19 / Mac Magazin and MacEasy Magazine CD - Issue 19.iso / Utilities / uae-0.4 / Source Code / CPU Sources / cpu1.c < prev    next >
C/C++ Source or Header  |  1996-02-13  |  33KB  |  1,157 lines
  1. #include "config.h"
  2. #include "amiga.h"
  3. #include "options.h"
  4. #include <stdlib.h>
  5. #include "memory.h"
  6. #include "custom.h"
  7. #include "newcpu.h"
  8. #include "cputbl.h"
  9. void op_1000(UWORD opcode)
  10. {
  11.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  12.     ULONG dstreg = (opcode & 3584) >> 9;
  13. {{    BYTE src = regs.d[srcreg];
  14. {    regs.v = regs.c = 0;
  15.     regs.z = ((BYTE)(src)) == 0;
  16.     regs.n = ((BYTE)(src)) < 0;
  17.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  18. }}}}
  19. void op_1010(UWORD opcode)
  20. {
  21.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  22.     ULONG dstreg = (opcode & 3584) >> 9;
  23. {{    CPTR srca = regs.a[srcreg];
  24.     BYTE src = get_byte(srca);
  25. {    regs.v = regs.c = 0;
  26.     regs.z = ((BYTE)(src)) == 0;
  27.     regs.n = ((BYTE)(src)) < 0;
  28.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  29. }}}}
  30. void op_1018(UWORD opcode)
  31. {
  32.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  33.     ULONG dstreg = (opcode & 3584) >> 9;
  34. {{    CPTR srca = regs.a[srcreg];
  35.     BYTE src = get_byte(srca);
  36. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  37. {    regs.v = regs.c = 0;
  38.     regs.z = ((BYTE)(src)) == 0;
  39.     regs.n = ((BYTE)(src)) < 0;
  40.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  41. }}}}}
  42. void op_1020(UWORD opcode)
  43. {
  44.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  45.     ULONG dstreg = (opcode & 3584) >> 9;
  46. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  47. {    CPTR srca = regs.a[srcreg];
  48.     BYTE src = get_byte(srca);
  49. {    regs.v = regs.c = 0;
  50.     regs.z = ((BYTE)(src)) == 0;
  51.     regs.n = ((BYTE)(src)) < 0;
  52.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  53. }}}}}
  54. void op_1028(UWORD opcode)
  55. {
  56.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  57.     ULONG dstreg = (opcode & 3584) >> 9;
  58. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  59.     BYTE src = get_byte(srca);
  60. {    regs.v = regs.c = 0;
  61.     regs.z = ((BYTE)(src)) == 0;
  62.     regs.n = ((BYTE)(src)) < 0;
  63.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  64. }}}}
  65. void op_1030(UWORD opcode)
  66. {
  67.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  68.     ULONG dstreg = (opcode & 3584) >> 9;
  69. {{    CPTR srca = regs.a[srcreg];
  70.     UWORD srcdp = nextiword();
  71.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  72. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  73.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  74.     srca += srcdpr;
  75. {    BYTE src = get_byte(srca);
  76. {    regs.v = regs.c = 0;
  77.     regs.z = ((BYTE)(src)) == 0;
  78.     regs.n = ((BYTE)(src)) < 0;
  79.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  80. }}}}}}
  81. void op_1038(UWORD opcode)
  82. {
  83.     ULONG dstreg = (opcode & 3584) >> 9;
  84. {{    CPTR srca = (LONG)(WORD)nextiword();
  85.     BYTE src = get_byte(srca);
  86. {    regs.v = regs.c = 0;
  87.     regs.z = ((BYTE)(src)) == 0;
  88.     regs.n = ((BYTE)(src)) < 0;
  89.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  90. }}}}
  91. void op_1039(UWORD opcode)
  92. {
  93.     ULONG dstreg = (opcode & 3584) >> 9;
  94. {{    CPTR srca = nextilong();
  95.     BYTE src = get_byte(srca);
  96. {    regs.v = regs.c = 0;
  97.     regs.z = ((BYTE)(src)) == 0;
  98.     regs.n = ((BYTE)(src)) < 0;
  99.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  100. }}}}
  101. void op_103a(UWORD opcode)
  102. {
  103.     ULONG dstreg = (opcode & 3584) >> 9;
  104. {{    CPTR srca = m68k_getpc();
  105.     srca += (LONG)(WORD)nextiword();
  106. {    BYTE src = get_byte(srca);
  107. {    regs.v = regs.c = 0;
  108.     regs.z = ((BYTE)(src)) == 0;
  109.     regs.n = ((BYTE)(src)) < 0;
  110.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  111. }}}}}
  112. void op_103b(UWORD opcode)
  113. {
  114.     ULONG dstreg = (opcode & 3584) >> 9;
  115. {{    CPTR srca = m68k_getpc();
  116.     UWORD srcdp = nextiword();
  117.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  118. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  119.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  120.     srca += srcdpr;
  121. {    BYTE src = get_byte(srca);
  122. {    regs.v = regs.c = 0;
  123.     regs.z = ((BYTE)(src)) == 0;
  124.     regs.n = ((BYTE)(src)) < 0;
  125.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  126. }}}}}}
  127. void op_103c(UWORD opcode)
  128. {
  129.     ULONG dstreg = (opcode & 3584) >> 9;
  130. {{    BYTE src = nextiword();
  131. {    regs.v = regs.c = 0;
  132.     regs.z = ((BYTE)(src)) == 0;
  133.     regs.n = ((BYTE)(src)) < 0;
  134.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  135. }}}}
  136. void op_1080(UWORD opcode)
  137. {
  138.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  139.     ULONG dstreg = (opcode & 3584) >> 9;
  140. {{    BYTE src = regs.d[srcreg];
  141. {    CPTR dsta = regs.a[dstreg];
  142.     regs.v = regs.c = 0;
  143.     regs.z = ((BYTE)(src)) == 0;
  144.     regs.n = ((BYTE)(src)) < 0;
  145.     put_byte(dsta,src);
  146. }}}}
  147. void op_1090(UWORD opcode)
  148. {
  149.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  150.     ULONG dstreg = (opcode & 3584) >> 9;
  151. {{    CPTR srca = regs.a[srcreg];
  152.     BYTE src = get_byte(srca);
  153. {    CPTR dsta = regs.a[dstreg];
  154.     regs.v = regs.c = 0;
  155.     regs.z = ((BYTE)(src)) == 0;
  156.     regs.n = ((BYTE)(src)) < 0;
  157.     put_byte(dsta,src);
  158. }}}}
  159. void op_1098(UWORD opcode)
  160. {
  161.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  162.     ULONG dstreg = (opcode & 3584) >> 9;
  163. {{    CPTR srca = regs.a[srcreg];
  164.     BYTE src = get_byte(srca);
  165. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  166. {    CPTR dsta = regs.a[dstreg];
  167.     regs.v = regs.c = 0;
  168.     regs.z = ((BYTE)(src)) == 0;
  169.     regs.n = ((BYTE)(src)) < 0;
  170.     put_byte(dsta,src);
  171. }}}}}
  172. void op_10a0(UWORD opcode)
  173. {
  174.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  175.     ULONG dstreg = (opcode & 3584) >> 9;
  176. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  177. {    CPTR srca = regs.a[srcreg];
  178.     BYTE src = get_byte(srca);
  179. {    CPTR dsta = regs.a[dstreg];
  180.     regs.v = regs.c = 0;
  181.     regs.z = ((BYTE)(src)) == 0;
  182.     regs.n = ((BYTE)(src)) < 0;
  183.     put_byte(dsta,src);
  184. }}}}}
  185. void op_10a8(UWORD opcode)
  186. {
  187.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  188.     ULONG dstreg = (opcode & 3584) >> 9;
  189. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  190.     BYTE src = get_byte(srca);
  191. {    CPTR dsta = regs.a[dstreg];
  192.     regs.v = regs.c = 0;
  193.     regs.z = ((BYTE)(src)) == 0;
  194.     regs.n = ((BYTE)(src)) < 0;
  195.     put_byte(dsta,src);
  196. }}}}
  197. void op_10b0(UWORD opcode)
  198. {
  199.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  200.     ULONG dstreg = (opcode & 3584) >> 9;
  201. {{    CPTR srca = regs.a[srcreg];
  202.     UWORD srcdp = nextiword();
  203.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  204. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  205.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  206.     srca += srcdpr;
  207. {    BYTE src = get_byte(srca);
  208. {    CPTR dsta = regs.a[dstreg];
  209.     regs.v = regs.c = 0;
  210.     regs.z = ((BYTE)(src)) == 0;
  211.     regs.n = ((BYTE)(src)) < 0;
  212.     put_byte(dsta,src);
  213. }}}}}}
  214. void op_10b8(UWORD opcode)
  215. {
  216.     ULONG dstreg = (opcode & 3584) >> 9;
  217. {{    CPTR srca = (LONG)(WORD)nextiword();
  218.     BYTE src = get_byte(srca);
  219. {    CPTR dsta = regs.a[dstreg];
  220.     regs.v = regs.c = 0;
  221.     regs.z = ((BYTE)(src)) == 0;
  222.     regs.n = ((BYTE)(src)) < 0;
  223.     put_byte(dsta,src);
  224. }}}}
  225. void op_10b9(UWORD opcode)
  226. {
  227.     ULONG dstreg = (opcode & 3584) >> 9;
  228. {{    CPTR srca = nextilong();
  229.     BYTE src = get_byte(srca);
  230. {    CPTR dsta = regs.a[dstreg];
  231.     regs.v = regs.c = 0;
  232.     regs.z = ((BYTE)(src)) == 0;
  233.     regs.n = ((BYTE)(src)) < 0;
  234.     put_byte(dsta,src);
  235. }}}}
  236. void op_10ba(UWORD opcode)
  237. {
  238.     ULONG dstreg = (opcode & 3584) >> 9;
  239. {{    CPTR srca = m68k_getpc();
  240.     srca += (LONG)(WORD)nextiword();
  241. {    BYTE src = get_byte(srca);
  242. {    CPTR dsta = regs.a[dstreg];
  243.     regs.v = regs.c = 0;
  244.     regs.z = ((BYTE)(src)) == 0;
  245.     regs.n = ((BYTE)(src)) < 0;
  246.     put_byte(dsta,src);
  247. }}}}}
  248. void op_10bb(UWORD opcode)
  249. {
  250.     ULONG dstreg = (opcode & 3584) >> 9;
  251. {{    CPTR srca = m68k_getpc();
  252.     UWORD srcdp = nextiword();
  253.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  254. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  255.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  256.     srca += srcdpr;
  257. {    BYTE src = get_byte(srca);
  258. {    CPTR dsta = regs.a[dstreg];
  259.     regs.v = regs.c = 0;
  260.     regs.z = ((BYTE)(src)) == 0;
  261.     regs.n = ((BYTE)(src)) < 0;
  262.     put_byte(dsta,src);
  263. }}}}}}
  264. void op_10bc(UWORD opcode)
  265. {
  266.     ULONG dstreg = (opcode & 3584) >> 9;
  267. {{    BYTE src = nextiword();
  268. {    CPTR dsta = regs.a[dstreg];
  269.     regs.v = regs.c = 0;
  270.     regs.z = ((BYTE)(src)) == 0;
  271.     regs.n = ((BYTE)(src)) < 0;
  272.     put_byte(dsta,src);
  273. }}}}
  274. void op_10c0(UWORD opcode)
  275. {
  276.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  277.     ULONG dstreg = (opcode & 3584) >> 9;
  278. {{    BYTE src = regs.d[srcreg];
  279. {    CPTR dsta = regs.a[dstreg];
  280. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  281.     regs.v = regs.c = 0;
  282.     regs.z = ((BYTE)(src)) == 0;
  283.     regs.n = ((BYTE)(src)) < 0;
  284.     put_byte(dsta,src);
  285. }}}}}
  286. void op_10d0(UWORD opcode)
  287. {
  288.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  289.     ULONG dstreg = (opcode & 3584) >> 9;
  290. {{    CPTR srca = regs.a[srcreg];
  291.     BYTE src = get_byte(srca);
  292. {    CPTR dsta = regs.a[dstreg];
  293. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  294.     regs.v = regs.c = 0;
  295.     regs.z = ((BYTE)(src)) == 0;
  296.     regs.n = ((BYTE)(src)) < 0;
  297.     put_byte(dsta,src);
  298. }}}}}
  299. void op_10d8(UWORD opcode)
  300. {
  301.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  302.     ULONG dstreg = (opcode & 3584) >> 9;
  303. {{    CPTR srca = regs.a[srcreg];
  304.     BYTE src = get_byte(srca);
  305. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  306. {    CPTR dsta = regs.a[dstreg];
  307. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  308.     regs.v = regs.c = 0;
  309.     regs.z = ((BYTE)(src)) == 0;
  310.     regs.n = ((BYTE)(src)) < 0;
  311.     put_byte(dsta,src);
  312. }}}}}}
  313. void op_10e0(UWORD opcode)
  314. {
  315.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  316.     ULONG dstreg = (opcode & 3584) >> 9;
  317. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  318. {    CPTR srca = regs.a[srcreg];
  319.     BYTE src = get_byte(srca);
  320. {    CPTR dsta = regs.a[dstreg];
  321. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  322.     regs.v = regs.c = 0;
  323.     regs.z = ((BYTE)(src)) == 0;
  324.     regs.n = ((BYTE)(src)) < 0;
  325.     put_byte(dsta,src);
  326. }}}}}}
  327. void op_10e8(UWORD opcode)
  328. {
  329.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  330.     ULONG dstreg = (opcode & 3584) >> 9;
  331. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  332.     BYTE src = get_byte(srca);
  333. {    CPTR dsta = regs.a[dstreg];
  334. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  335.     regs.v = regs.c = 0;
  336.     regs.z = ((BYTE)(src)) == 0;
  337.     regs.n = ((BYTE)(src)) < 0;
  338.     put_byte(dsta,src);
  339. }}}}}
  340. void op_10f0(UWORD opcode)
  341. {
  342.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  343.     ULONG dstreg = (opcode & 3584) >> 9;
  344. {{    CPTR srca = regs.a[srcreg];
  345.     UWORD srcdp = nextiword();
  346.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  347. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  348.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  349.     srca += srcdpr;
  350. {    BYTE src = get_byte(srca);
  351. {    CPTR dsta = regs.a[dstreg];
  352. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  353.     regs.v = regs.c = 0;
  354.     regs.z = ((BYTE)(src)) == 0;
  355.     regs.n = ((BYTE)(src)) < 0;
  356.     put_byte(dsta,src);
  357. }}}}}}}
  358. void op_10f8(UWORD opcode)
  359. {
  360.     ULONG dstreg = (opcode & 3584) >> 9;
  361. {{    CPTR srca = (LONG)(WORD)nextiword();
  362.     BYTE src = get_byte(srca);
  363. {    CPTR dsta = regs.a[dstreg];
  364. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  365.     regs.v = regs.c = 0;
  366.     regs.z = ((BYTE)(src)) == 0;
  367.     regs.n = ((BYTE)(src)) < 0;
  368.     put_byte(dsta,src);
  369. }}}}}
  370. void op_10f9(UWORD opcode)
  371. {
  372.     ULONG dstreg = (opcode & 3584) >> 9;
  373. {{    CPTR srca = nextilong();
  374.     BYTE src = get_byte(srca);
  375. {    CPTR dsta = regs.a[dstreg];
  376. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  377.     regs.v = regs.c = 0;
  378.     regs.z = ((BYTE)(src)) == 0;
  379.     regs.n = ((BYTE)(src)) < 0;
  380.     put_byte(dsta,src);
  381. }}}}}
  382. void op_10fa(UWORD opcode)
  383. {
  384.     ULONG dstreg = (opcode & 3584) >> 9;
  385. {{    CPTR srca = m68k_getpc();
  386.     srca += (LONG)(WORD)nextiword();
  387. {    BYTE src = get_byte(srca);
  388. {    CPTR dsta = regs.a[dstreg];
  389. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  390.     regs.v = regs.c = 0;
  391.     regs.z = ((BYTE)(src)) == 0;
  392.     regs.n = ((BYTE)(src)) < 0;
  393.     put_byte(dsta,src);
  394. }}}}}}
  395. void op_10fb(UWORD opcode)
  396. {
  397.     ULONG dstreg = (opcode & 3584) >> 9;
  398. {{    CPTR srca = m68k_getpc();
  399.     UWORD srcdp = nextiword();
  400.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  401. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  402.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  403.     srca += srcdpr;
  404. {    BYTE src = get_byte(srca);
  405. {    CPTR dsta = regs.a[dstreg];
  406. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  407.     regs.v = regs.c = 0;
  408.     regs.z = ((BYTE)(src)) == 0;
  409.     regs.n = ((BYTE)(src)) < 0;
  410.     put_byte(dsta,src);
  411. }}}}}}}
  412. void op_10fc(UWORD opcode)
  413. {
  414.     ULONG dstreg = (opcode & 3584) >> 9;
  415. {{    BYTE src = nextiword();
  416. {    CPTR dsta = regs.a[dstreg];
  417. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  418.     regs.v = regs.c = 0;
  419.     regs.z = ((BYTE)(src)) == 0;
  420.     regs.n = ((BYTE)(src)) < 0;
  421.     put_byte(dsta,src);
  422. }}}}}
  423. void op_1100(UWORD opcode)
  424. {
  425.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  426.     ULONG dstreg = (opcode & 3584) >> 9;
  427. {{    BYTE src = regs.d[srcreg];
  428. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  429. {    CPTR dsta = regs.a[dstreg];
  430.     regs.v = regs.c = 0;
  431.     regs.z = ((BYTE)(src)) == 0;
  432.     regs.n = ((BYTE)(src)) < 0;
  433.     put_byte(dsta,src);
  434. }}}}}
  435. void op_1110(UWORD opcode)
  436. {
  437.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  438.     ULONG dstreg = (opcode & 3584) >> 9;
  439. {{    CPTR srca = regs.a[srcreg];
  440.     BYTE src = get_byte(srca);
  441. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  442. {    CPTR dsta = regs.a[dstreg];
  443.     regs.v = regs.c = 0;
  444.     regs.z = ((BYTE)(src)) == 0;
  445.     regs.n = ((BYTE)(src)) < 0;
  446.     put_byte(dsta,src);
  447. }}}}}
  448. void op_1118(UWORD opcode)
  449. {
  450.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  451.     ULONG dstreg = (opcode & 3584) >> 9;
  452. {{    CPTR srca = regs.a[srcreg];
  453.     BYTE src = get_byte(srca);
  454. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  455. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  456. {    CPTR dsta = regs.a[dstreg];
  457.     regs.v = regs.c = 0;
  458.     regs.z = ((BYTE)(src)) == 0;
  459.     regs.n = ((BYTE)(src)) < 0;
  460.     put_byte(dsta,src);
  461. }}}}}}
  462. void op_1120(UWORD opcode)
  463. {
  464.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  465.     ULONG dstreg = (opcode & 3584) >> 9;
  466. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  467. {    CPTR srca = regs.a[srcreg];
  468.     BYTE src = get_byte(srca);
  469. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  470. {    CPTR dsta = regs.a[dstreg];
  471.     regs.v = regs.c = 0;
  472.     regs.z = ((BYTE)(src)) == 0;
  473.     regs.n = ((BYTE)(src)) < 0;
  474.     put_byte(dsta,src);
  475. }}}}}}
  476. void op_1128(UWORD opcode)
  477. {
  478.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  479.     ULONG dstreg = (opcode & 3584) >> 9;
  480. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  481.     BYTE src = get_byte(srca);
  482. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  483. {    CPTR dsta = regs.a[dstreg];
  484.     regs.v = regs.c = 0;
  485.     regs.z = ((BYTE)(src)) == 0;
  486.     regs.n = ((BYTE)(src)) < 0;
  487.     put_byte(dsta,src);
  488. }}}}}
  489. void op_1130(UWORD opcode)
  490. {
  491.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  492.     ULONG dstreg = (opcode & 3584) >> 9;
  493. {{    CPTR srca = regs.a[srcreg];
  494.     UWORD srcdp = nextiword();
  495.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  496. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  497.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  498.     srca += srcdpr;
  499. {    BYTE src = get_byte(srca);
  500. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  501. {    CPTR dsta = regs.a[dstreg];
  502.     regs.v = regs.c = 0;
  503.     regs.z = ((BYTE)(src)) == 0;
  504.     regs.n = ((BYTE)(src)) < 0;
  505.     put_byte(dsta,src);
  506. }}}}}}}
  507. void op_1138(UWORD opcode)
  508. {
  509.     ULONG dstreg = (opcode & 3584) >> 9;
  510. {{    CPTR srca = (LONG)(WORD)nextiword();
  511.     BYTE src = get_byte(srca);
  512. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  513. {    CPTR dsta = regs.a[dstreg];
  514.     regs.v = regs.c = 0;
  515.     regs.z = ((BYTE)(src)) == 0;
  516.     regs.n = ((BYTE)(src)) < 0;
  517.     put_byte(dsta,src);
  518. }}}}}
  519. void op_1139(UWORD opcode)
  520. {
  521.     ULONG dstreg = (opcode & 3584) >> 9;
  522. {{    CPTR srca = nextilong();
  523.     BYTE src = get_byte(srca);
  524. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  525. {    CPTR dsta = regs.a[dstreg];
  526.     regs.v = regs.c = 0;
  527.     regs.z = ((BYTE)(src)) == 0;
  528.     regs.n = ((BYTE)(src)) < 0;
  529.     put_byte(dsta,src);
  530. }}}}}
  531. void op_113a(UWORD opcode)
  532. {
  533.     ULONG dstreg = (opcode & 3584) >> 9;
  534. {{    CPTR srca = m68k_getpc();
  535.     srca += (LONG)(WORD)nextiword();
  536. {    BYTE src = get_byte(srca);
  537. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  538. {    CPTR dsta = regs.a[dstreg];
  539.     regs.v = regs.c = 0;
  540.     regs.z = ((BYTE)(src)) == 0;
  541.     regs.n = ((BYTE)(src)) < 0;
  542.     put_byte(dsta,src);
  543. }}}}}}
  544. void op_113b(UWORD opcode)
  545. {
  546.     ULONG dstreg = (opcode & 3584) >> 9;
  547. {{    CPTR srca = m68k_getpc();
  548.     UWORD srcdp = nextiword();
  549.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  550. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  551.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  552.     srca += srcdpr;
  553. {    BYTE src = get_byte(srca);
  554. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  555. {    CPTR dsta = regs.a[dstreg];
  556.     regs.v = regs.c = 0;
  557.     regs.z = ((BYTE)(src)) == 0;
  558.     regs.n = ((BYTE)(src)) < 0;
  559.     put_byte(dsta,src);
  560. }}}}}}}
  561. void op_113c(UWORD opcode)
  562. {
  563.     ULONG dstreg = (opcode & 3584) >> 9;
  564. {{    BYTE src = nextiword();
  565. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  566. {    CPTR dsta = regs.a[dstreg];
  567.     regs.v = regs.c = 0;
  568.     regs.z = ((BYTE)(src)) == 0;
  569.     regs.n = ((BYTE)(src)) < 0;
  570.     put_byte(dsta,src);
  571. }}}}}
  572. void op_1140(UWORD opcode)
  573. {
  574.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  575.     ULONG dstreg = (opcode & 3584) >> 9;
  576. {{    BYTE src = regs.d[srcreg];
  577. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  578.     regs.v = regs.c = 0;
  579.     regs.z = ((BYTE)(src)) == 0;
  580.     regs.n = ((BYTE)(src)) < 0;
  581.     put_byte(dsta,src);
  582. }}}}
  583. void op_1150(UWORD opcode)
  584. {
  585.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  586.     ULONG dstreg = (opcode & 3584) >> 9;
  587. {{    CPTR srca = regs.a[srcreg];
  588.     BYTE src = get_byte(srca);
  589. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  590.     regs.v = regs.c = 0;
  591.     regs.z = ((BYTE)(src)) == 0;
  592.     regs.n = ((BYTE)(src)) < 0;
  593.     put_byte(dsta,src);
  594. }}}}
  595. void op_1158(UWORD opcode)
  596. {
  597.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  598.     ULONG dstreg = (opcode & 3584) >> 9;
  599. {{    CPTR srca = regs.a[srcreg];
  600.     BYTE src = get_byte(srca);
  601. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  602. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  603.     regs.v = regs.c = 0;
  604.     regs.z = ((BYTE)(src)) == 0;
  605.     regs.n = ((BYTE)(src)) < 0;
  606.     put_byte(dsta,src);
  607. }}}}}
  608. void op_1160(UWORD opcode)
  609. {
  610.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  611.     ULONG dstreg = (opcode & 3584) >> 9;
  612. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  613. {    CPTR srca = regs.a[srcreg];
  614.     BYTE src = get_byte(srca);
  615. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  616.     regs.v = regs.c = 0;
  617.     regs.z = ((BYTE)(src)) == 0;
  618.     regs.n = ((BYTE)(src)) < 0;
  619.     put_byte(dsta,src);
  620. }}}}}
  621. void op_1168(UWORD opcode)
  622. {
  623.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  624.     ULONG dstreg = (opcode & 3584) >> 9;
  625. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  626.     BYTE src = get_byte(srca);
  627. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  628.     regs.v = regs.c = 0;
  629.     regs.z = ((BYTE)(src)) == 0;
  630.     regs.n = ((BYTE)(src)) < 0;
  631.     put_byte(dsta,src);
  632. }}}}
  633. void op_1170(UWORD opcode)
  634. {
  635.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  636.     ULONG dstreg = (opcode & 3584) >> 9;
  637. {{    CPTR srca = regs.a[srcreg];
  638.     UWORD srcdp = nextiword();
  639.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  640. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  641.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  642.     srca += srcdpr;
  643. {    BYTE src = get_byte(srca);
  644. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  645.     regs.v = regs.c = 0;
  646.     regs.z = ((BYTE)(src)) == 0;
  647.     regs.n = ((BYTE)(src)) < 0;
  648.     put_byte(dsta,src);
  649. }}}}}}
  650. void op_1178(UWORD opcode)
  651. {
  652.     ULONG dstreg = (opcode & 3584) >> 9;
  653. {{    CPTR srca = (LONG)(WORD)nextiword();
  654.     BYTE src = get_byte(srca);
  655. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  656.     regs.v = regs.c = 0;
  657.     regs.z = ((BYTE)(src)) == 0;
  658.     regs.n = ((BYTE)(src)) < 0;
  659.     put_byte(dsta,src);
  660. }}}}
  661. void op_1179(UWORD opcode)
  662. {
  663.     ULONG dstreg = (opcode & 3584) >> 9;
  664. {{    CPTR srca = nextilong();
  665.     BYTE src = get_byte(srca);
  666. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  667.     regs.v = regs.c = 0;
  668.     regs.z = ((BYTE)(src)) == 0;
  669.     regs.n = ((BYTE)(src)) < 0;
  670.     put_byte(dsta,src);
  671. }}}}
  672. void op_117a(UWORD opcode)
  673. {
  674.     ULONG dstreg = (opcode & 3584) >> 9;
  675. {{    CPTR srca = m68k_getpc();
  676.     srca += (LONG)(WORD)nextiword();
  677. {    BYTE src = get_byte(srca);
  678. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  679.     regs.v = regs.c = 0;
  680.     regs.z = ((BYTE)(src)) == 0;
  681.     regs.n = ((BYTE)(src)) < 0;
  682.     put_byte(dsta,src);
  683. }}}}}
  684. void op_117b(UWORD opcode)
  685. {
  686.     ULONG dstreg = (opcode & 3584) >> 9;
  687. {{    CPTR srca = m68k_getpc();
  688.     UWORD srcdp = nextiword();
  689.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  690. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  691.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  692.     srca += srcdpr;
  693. {    BYTE src = get_byte(srca);
  694. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  695.     regs.v = regs.c = 0;
  696.     regs.z = ((BYTE)(src)) == 0;
  697.     regs.n = ((BYTE)(src)) < 0;
  698.     put_byte(dsta,src);
  699. }}}}}}
  700. void op_117c(UWORD opcode)
  701. {
  702.     ULONG dstreg = (opcode & 3584) >> 9;
  703. {{    BYTE src = nextiword();
  704. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  705.     regs.v = regs.c = 0;
  706.     regs.z = ((BYTE)(src)) == 0;
  707.     regs.n = ((BYTE)(src)) < 0;
  708.     put_byte(dsta,src);
  709. }}}}
  710. void op_1180(UWORD opcode)
  711. {
  712.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  713.     ULONG dstreg = (opcode & 3584) >> 9;
  714. {{    BYTE src = regs.d[srcreg];
  715. {    CPTR dsta = regs.a[dstreg];
  716.     UWORD dstdp = nextiword();
  717.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  718. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  719.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  720.     dsta += dstdpr;
  721.     regs.v = regs.c = 0;
  722.     regs.z = ((BYTE)(src)) == 0;
  723.     regs.n = ((BYTE)(src)) < 0;
  724.     put_byte(dsta,src);
  725. }}}}}
  726. void op_1190(UWORD opcode)
  727. {
  728.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  729.     ULONG dstreg = (opcode & 3584) >> 9;
  730. {{    CPTR srca = regs.a[srcreg];
  731.     BYTE src = get_byte(srca);
  732. {    CPTR dsta = regs.a[dstreg];
  733.     UWORD dstdp = nextiword();
  734.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  735. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  736.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  737.     dsta += dstdpr;
  738.     regs.v = regs.c = 0;
  739.     regs.z = ((BYTE)(src)) == 0;
  740.     regs.n = ((BYTE)(src)) < 0;
  741.     put_byte(dsta,src);
  742. }}}}}
  743. void op_1198(UWORD opcode)
  744. {
  745.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  746.     ULONG dstreg = (opcode & 3584) >> 9;
  747. {{    CPTR srca = regs.a[srcreg];
  748.     BYTE src = get_byte(srca);
  749. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  750. {    CPTR dsta = regs.a[dstreg];
  751.     UWORD dstdp = nextiword();
  752.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  753. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  754.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  755.     dsta += dstdpr;
  756.     regs.v = regs.c = 0;
  757.     regs.z = ((BYTE)(src)) == 0;
  758.     regs.n = ((BYTE)(src)) < 0;
  759.     put_byte(dsta,src);
  760. }}}}}}
  761. void op_11a0(UWORD opcode)
  762. {
  763.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  764.     ULONG dstreg = (opcode & 3584) >> 9;
  765. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  766. {    CPTR srca = regs.a[srcreg];
  767.     BYTE src = get_byte(srca);
  768. {    CPTR dsta = regs.a[dstreg];
  769.     UWORD dstdp = nextiword();
  770.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  771. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  772.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  773.     dsta += dstdpr;
  774.     regs.v = regs.c = 0;
  775.     regs.z = ((BYTE)(src)) == 0;
  776.     regs.n = ((BYTE)(src)) < 0;
  777.     put_byte(dsta,src);
  778. }}}}}}
  779. void op_11a8(UWORD opcode)
  780. {
  781.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  782.     ULONG dstreg = (opcode & 3584) >> 9;
  783. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  784.     BYTE src = get_byte(srca);
  785. {    CPTR dsta = regs.a[dstreg];
  786.     UWORD dstdp = nextiword();
  787.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  788. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  789.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  790.     dsta += dstdpr;
  791.     regs.v = regs.c = 0;
  792.     regs.z = ((BYTE)(src)) == 0;
  793.     regs.n = ((BYTE)(src)) < 0;
  794.     put_byte(dsta,src);
  795. }}}}}
  796. void op_11b0(UWORD opcode)
  797. {
  798.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  799.     ULONG dstreg = (opcode & 3584) >> 9;
  800. {{    CPTR srca = regs.a[srcreg];
  801.     UWORD srcdp = nextiword();
  802.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  803. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  804.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  805.     srca += srcdpr;
  806. {    BYTE src = get_byte(srca);
  807. {    CPTR dsta = regs.a[dstreg];
  808.     UWORD dstdp = nextiword();
  809.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  810. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  811.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  812.     dsta += dstdpr;
  813.     regs.v = regs.c = 0;
  814.     regs.z = ((BYTE)(src)) == 0;
  815.     regs.n = ((BYTE)(src)) < 0;
  816.     put_byte(dsta,src);
  817. }}}}}}}
  818. void op_11b8(UWORD opcode)
  819. {
  820.     ULONG dstreg = (opcode & 3584) >> 9;
  821. {{    CPTR srca = (LONG)(WORD)nextiword();
  822.     BYTE src = get_byte(srca);
  823. {    CPTR dsta = regs.a[dstreg];
  824.     UWORD dstdp = nextiword();
  825.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  826. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  827.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  828.     dsta += dstdpr;
  829.     regs.v = regs.c = 0;
  830.     regs.z = ((BYTE)(src)) == 0;
  831.     regs.n = ((BYTE)(src)) < 0;
  832.     put_byte(dsta,src);
  833. }}}}}
  834. void op_11b9(UWORD opcode)
  835. {
  836.     ULONG dstreg = (opcode & 3584) >> 9;
  837. {{    CPTR srca = nextilong();
  838.     BYTE src = get_byte(srca);
  839. {    CPTR dsta = regs.a[dstreg];
  840.     UWORD dstdp = nextiword();
  841.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  842. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  843.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  844.     dsta += dstdpr;
  845.     regs.v = regs.c = 0;
  846.     regs.z = ((BYTE)(src)) == 0;
  847.     regs.n = ((BYTE)(src)) < 0;
  848.     put_byte(dsta,src);
  849. }}}}}
  850. void op_11ba(UWORD opcode)
  851. {
  852.     ULONG dstreg = (opcode & 3584) >> 9;
  853. {{    CPTR srca = m68k_getpc();
  854.     srca += (LONG)(WORD)nextiword();
  855. {    BYTE src = get_byte(srca);
  856. {    CPTR dsta = regs.a[dstreg];
  857.     UWORD dstdp = nextiword();
  858.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  859. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  860.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  861.     dsta += dstdpr;
  862.     regs.v = regs.c = 0;
  863.     regs.z = ((BYTE)(src)) == 0;
  864.     regs.n = ((BYTE)(src)) < 0;
  865.     put_byte(dsta,src);
  866. }}}}}}
  867. void op_11bb(UWORD opcode)
  868. {
  869.     ULONG dstreg = (opcode & 3584) >> 9;
  870. {{    CPTR srca = m68k_getpc();
  871.     UWORD srcdp = nextiword();
  872.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  873. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  874.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  875.     srca += srcdpr;
  876. {    BYTE src = get_byte(srca);
  877. {    CPTR dsta = regs.a[dstreg];
  878.     UWORD dstdp = nextiword();
  879.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  880. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  881.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  882.     dsta += dstdpr;
  883.     regs.v = regs.c = 0;
  884.     regs.z = ((BYTE)(src)) == 0;
  885.     regs.n = ((BYTE)(src)) < 0;
  886.     put_byte(dsta,src);
  887. }}}}}}}
  888. void op_11bc(UWORD opcode)
  889. {
  890.     ULONG dstreg = (opcode & 3584) >> 9;
  891. {{    BYTE src = nextiword();
  892. {    CPTR dsta = regs.a[dstreg];
  893.     UWORD dstdp = nextiword();
  894.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  895. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  896.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  897.     dsta += dstdpr;
  898.     regs.v = regs.c = 0;
  899.     regs.z = ((BYTE)(src)) == 0;
  900.     regs.n = ((BYTE)(src)) < 0;
  901.     put_byte(dsta,src);
  902. }}}}}
  903. void op_11c0(UWORD opcode)
  904. {
  905.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  906. {{    BYTE src = regs.d[srcreg];
  907. {    CPTR dsta = (LONG)(WORD)nextiword();
  908.     regs.v = regs.c = 0;
  909.     regs.z = ((BYTE)(src)) == 0;
  910.     regs.n = ((BYTE)(src)) < 0;
  911.     put_byte(dsta,src);
  912. }}}}
  913. void op_11d0(UWORD opcode)
  914. {
  915.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  916. {{    CPTR srca = regs.a[srcreg];
  917.     BYTE src = get_byte(srca);
  918. {    CPTR dsta = (LONG)(WORD)nextiword();
  919.     regs.v = regs.c = 0;
  920.     regs.z = ((BYTE)(src)) == 0;
  921.     regs.n = ((BYTE)(src)) < 0;
  922.     put_byte(dsta,src);
  923. }}}}
  924. void op_11d8(UWORD opcode)
  925. {
  926.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  927. {{    CPTR srca = regs.a[srcreg];
  928.     BYTE src = get_byte(srca);
  929. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  930. {    CPTR dsta = (LONG)(WORD)nextiword();
  931.     regs.v = regs.c = 0;
  932.     regs.z = ((BYTE)(src)) == 0;
  933.     regs.n = ((BYTE)(src)) < 0;
  934.     put_byte(dsta,src);
  935. }}}}}
  936. void op_11e0(UWORD opcode)
  937. {
  938.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  939. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  940. {    CPTR srca = regs.a[srcreg];
  941.     BYTE src = get_byte(srca);
  942. {    CPTR dsta = (LONG)(WORD)nextiword();
  943.     regs.v = regs.c = 0;
  944.     regs.z = ((BYTE)(src)) == 0;
  945.     regs.n = ((BYTE)(src)) < 0;
  946.     put_byte(dsta,src);
  947. }}}}}
  948. void op_11e8(UWORD opcode)
  949. {
  950.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  951. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  952.     BYTE src = get_byte(srca);
  953. {    CPTR dsta = (LONG)(WORD)nextiword();
  954.     regs.v = regs.c = 0;
  955.     regs.z = ((BYTE)(src)) == 0;
  956.     regs.n = ((BYTE)(src)) < 0;
  957.     put_byte(dsta,src);
  958. }}}}
  959. void op_11f0(UWORD opcode)
  960. {
  961.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  962. {{    CPTR srca = regs.a[srcreg];
  963.     UWORD srcdp = nextiword();
  964.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  965. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  966.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  967.     srca += srcdpr;
  968. {    BYTE src = get_byte(srca);
  969. {    CPTR dsta = (LONG)(WORD)nextiword();
  970.     regs.v = regs.c = 0;
  971.     regs.z = ((BYTE)(src)) == 0;
  972.     regs.n = ((BYTE)(src)) < 0;
  973.     put_byte(dsta,src);
  974. }}}}}}
  975. void op_11f8(UWORD opcode)
  976. {
  977. {{    CPTR srca = (LONG)(WORD)nextiword();
  978.     BYTE src = get_byte(srca);
  979. {    CPTR dsta = (LONG)(WORD)nextiword();
  980.     regs.v = regs.c = 0;
  981.     regs.z = ((BYTE)(src)) == 0;
  982.     regs.n = ((BYTE)(src)) < 0;
  983.     put_byte(dsta,src);
  984. }}}}
  985. void op_11f9(UWORD opcode)
  986. {
  987. {{    CPTR srca = nextilong();
  988.     BYTE src = get_byte(srca);
  989. {    CPTR dsta = (LONG)(WORD)nextiword();
  990.     regs.v = regs.c = 0;
  991.     regs.z = ((BYTE)(src)) == 0;
  992.     regs.n = ((BYTE)(src)) < 0;
  993.     put_byte(dsta,src);
  994. }}}}
  995. void op_11fa(UWORD opcode)
  996. {
  997. {{    CPTR srca = m68k_getpc();
  998.     srca += (LONG)(WORD)nextiword();
  999. {    BYTE src = get_byte(srca);
  1000. {    CPTR dsta = (LONG)(WORD)nextiword();
  1001.     regs.v = regs.c = 0;
  1002.     regs.z = ((BYTE)(src)) == 0;
  1003.     regs.n = ((BYTE)(src)) < 0;
  1004.     put_byte(dsta,src);
  1005. }}}}}
  1006. void op_11fb(UWORD opcode)
  1007. {
  1008. {{    CPTR srca = m68k_getpc();
  1009.     UWORD srcdp = nextiword();
  1010.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  1011. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  1012.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  1013.     srca += srcdpr;
  1014. {    BYTE src = get_byte(srca);
  1015. {    CPTR dsta = (LONG)(WORD)nextiword();
  1016.     regs.v = regs.c = 0;
  1017.     regs.z = ((BYTE)(src)) == 0;
  1018.     regs.n = ((BYTE)(src)) < 0;
  1019.     put_byte(dsta,src);
  1020. }}}}}}
  1021. void op_11fc(UWORD opcode)
  1022. {
  1023. {{    BYTE src = nextiword();
  1024. {    CPTR dsta = (LONG)(WORD)nextiword();
  1025.     regs.v = regs.c = 0;
  1026.     regs.z = ((BYTE)(src)) == 0;
  1027.     regs.n = ((BYTE)(src)) < 0;
  1028.     put_byte(dsta,src);
  1029. }}}}
  1030. void op_13c0(UWORD opcode)
  1031. {
  1032.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1033. {{    BYTE src = regs.d[srcreg];
  1034. {    CPTR dsta = nextilong();
  1035.     regs.v = regs.c = 0;
  1036.     regs.z = ((BYTE)(src)) == 0;
  1037.     regs.n = ((BYTE)(src)) < 0;
  1038.     put_byte(dsta,src);
  1039. }}}}
  1040. void op_13d0(UWORD opcode)
  1041. {
  1042.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1043. {{    CPTR srca = regs.a[srcreg];
  1044.     BYTE src = get_byte(srca);
  1045. {    CPTR dsta = nextilong();
  1046.     regs.v = regs.c = 0;
  1047.     regs.z = ((BYTE)(src)) == 0;
  1048.     regs.n = ((BYTE)(src)) < 0;
  1049.     put_byte(dsta,src);
  1050. }}}}
  1051. void op_13d8(UWORD opcode)
  1052. {
  1053.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1054. {{    CPTR srca = regs.a[srcreg];
  1055.     BYTE src = get_byte(srca);
  1056. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  1057. {    CPTR dsta = nextilong();
  1058.     regs.v = regs.c = 0;
  1059.     regs.z = ((BYTE)(src)) == 0;
  1060.     regs.n = ((BYTE)(src)) < 0;
  1061.     put_byte(dsta,src);
  1062. }}}}}
  1063. void op_13e0(UWORD opcode)
  1064. {
  1065.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1066. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  1067. {    CPTR srca = regs.a[srcreg];
  1068.     BYTE src = get_byte(srca);
  1069. {    CPTR dsta = nextilong();
  1070.     regs.v = regs.c = 0;
  1071.     regs.z = ((BYTE)(src)) == 0;
  1072.     regs.n = ((BYTE)(src)) < 0;
  1073.     put_byte(dsta,src);
  1074. }}}}}
  1075. void op_13e8(UWORD opcode)
  1076. {
  1077.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1078. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  1079.     BYTE src = get_byte(srca);
  1080. {    CPTR dsta = nextilong();
  1081.     regs.v = regs.c = 0;
  1082.     regs.z = ((BYTE)(src)) == 0;
  1083.     regs.n = ((BYTE)(src)) < 0;
  1084.     put_byte(dsta,src);
  1085. }}}}
  1086. void op_13f0(UWORD opcode)
  1087. {
  1088.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1089. {{    CPTR srca = regs.a[srcreg];
  1090.     UWORD srcdp = nextiword();
  1091.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  1092. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  1093.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  1094.     srca += srcdpr;
  1095. {    BYTE src = get_byte(srca);
  1096. {    CPTR dsta = nextilong();
  1097.     regs.v = regs.c = 0;
  1098.     regs.z = ((BYTE)(src)) == 0;
  1099.     regs.n = ((BYTE)(src)) < 0;
  1100.     put_byte(dsta,src);
  1101. }}}}}}
  1102. void op_13f8(UWORD opcode)
  1103. {
  1104. {{    CPTR srca = (LONG)(WORD)nextiword();
  1105.     BYTE src = get_byte(srca);
  1106. {    CPTR dsta = nextilong();
  1107.     regs.v = regs.c = 0;
  1108.     regs.z = ((BYTE)(src)) == 0;
  1109.     regs.n = ((BYTE)(src)) < 0;
  1110.     put_byte(dsta,src);
  1111. }}}}
  1112. void op_13f9(UWORD opcode)
  1113. {
  1114. {{    CPTR srca = nextilong();
  1115.     BYTE src = get_byte(srca);
  1116. {    CPTR dsta = nextilong();
  1117.     regs.v = regs.c = 0;
  1118.     regs.z = ((BYTE)(src)) == 0;
  1119.     regs.n = ((BYTE)(src)) < 0;
  1120.     put_byte(dsta,src);
  1121. }}}}
  1122. void op_13fa(UWORD opcode)
  1123. {
  1124. {{    CPTR srca = m68k_getpc();
  1125.     srca += (LONG)(WORD)nextiword();
  1126. {    BYTE src = get_byte(srca);
  1127. {    CPTR dsta = nextilong();
  1128.     regs.v = regs.c = 0;
  1129.     regs.z = ((BYTE)(src)) == 0;
  1130.     regs.n = ((BYTE)(src)) < 0;
  1131.     put_byte(dsta,src);
  1132. }}}}}
  1133. void op_13fb(UWORD opcode)
  1134. {
  1135. {{    CPTR srca = m68k_getpc();
  1136.     UWORD srcdp = nextiword();
  1137.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  1138. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  1139.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  1140.     srca += srcdpr;
  1141. {    BYTE src = get_byte(srca);
  1142. {    CPTR dsta = nextilong();
  1143.     regs.v = regs.c = 0;
  1144.     regs.z = ((BYTE)(src)) == 0;
  1145.     regs.n = ((BYTE)(src)) < 0;
  1146.     put_byte(dsta,src);
  1147. }}}}}}
  1148. void op_13fc(UWORD opcode)
  1149. {
  1150. {{    BYTE src = nextiword();
  1151. {    CPTR dsta = nextilong();
  1152.     regs.v = regs.c = 0;
  1153.     regs.z = ((BYTE)(src)) == 0;
  1154.     regs.n = ((BYTE)(src)) < 0;
  1155.     put_byte(dsta,src);
  1156. }}}}
  1157.